﻿//#include <iostream>
//using namespace std;

//class Same
//{
//public:
//	void identity() //身份认证
//	{
//		//...
//	}
//protected:
//	string _name; //姓名
//	size_t _age;  //年龄
//	string _add;  //住址
//	string _tel;  //电话
//};
//
////学生
//class Student : public Same
//{
//public:
//	void study() //学习
//	{
//		//...
//	}
//
//protected:
//	string _stuid;//学号 
//};
//
////老师
//class Teacher : public Same 
//{
//public:
//	void teaching() //教书
//	{
//		//...
//	}
//
//protected:
//	string _title;//职称
//};



#include <iostream>
#include <vector>
using namespace std;

//
//#define CONTAINER std::vector
//template<class T>
//class stack : public CONTAINER<T> //继承vector
//{
//public:
//	void push(const T& x)
//	{
//		CONTAINER<T>::push_back(x);
//	}
//	void pop()
//	{
//		CONTAINER<T>::pop_back();
//	}
//	const T& top()
//	{
//		return CONTAINER<T>::back();
//	}
//	bool empty()
//	{
//		return CONTAINER<T>::empty();
//	}
//};
//
//int main()
//{
//	stack <int> st;
//	return 0;
//}
//
//class Same
//{
//protected:
//	string _name = "123";
//	size_t _age; 
//};
//
////学生
//class Student : public Same
//{
//public:
//	void study() //学习
//	{
//		//...
//	}
//
//protected:
//	string _stuid;//学号 
//};
//
////老师
//class Teacher : public Same
//{
//public:
//	void Print()
//	{
//		cout << Same::_name << endl;
//	}
//protected:
//	string _name = "456";
//};
//
//void test1()
//{
//	//Student st;//子类对象
//	//Same sa; //子类对象赋值给父类对象
//	//Same* psa = &st;//子类对象赋值给父类指针
//	//Same& rsa = sa; //子类对象赋值给父类引用
//
//	Student st;//子类对象
//	Same sa; //父类对象
//	sa = st;//子类赋值给父类（可以）
//	//	st = sa;//父类赋值给子类（不可以）
//
//}
//
//int main()
//{
//	Teacher t;
//	t.Print();
//	return 0;
//}

//
//
//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//
//
//int main()
//{
//	B b;
//	b.fun(10);
//	b.A::fun(); //指定
//	return 0;
//};

//class Same //基类
//{
//public:
//	Same(const char* name = "peter") //默认构造
//		: _name(name)
//	{
//		cout << "Same()" << endl;
//	}
//	Same(const Same& p) //拷贝构造
//		: _name(p._name)
//	{
//		cout << "Same(const Same& p)" << endl;
//	}
//	Same& operator=(const Same& p) //赋值重载
//	{
//		cout << "Same& operator=(const Same& p)" << endl;
//		if (this != &p)
//			_name = p._name;
//		return *this;
//	}
//	~Same() //析构
//	{
//		cout << "~Same()" << endl;
//	}
//protected:
//	string _name;
//};
//
//class Student : public Same //派生类
//{
//public:
//	Student(const char* string, int num, const char* add)
//		:Same(string) //在初始化列表阶段显示调用
//		, _num(num)
//		,_add(add)
//	{}
//	//
//	//Student(const Student& s) //显示地写子类的拷贝构造
//	//	:Same(s)//父类的拷贝构造
//	//	,_add(s._add)
//	//	,_num(s._num)
//	//{
//	//	//假设里面是深拷贝资源的拷贝逻辑
//	//}
//
//	Student& operator=(const Student& s)
//	{
//		if (this != &s)
//		{
//			Same::operator=(s);//显示调用基类的赋值重载
//			_num = s._num;
//			_add = s._add;
//			//深拷贝逻辑
//		}
//		return *this;
//	}
//
//	~Student()
//	{
//		//资源释放逻辑...
//		//自动调用父类析构
//	}
//
//protected:
//	int _num;
//	string _add;
//};
//
//int main()
//{
//	Student st1("张三", 0, "Chain");
//	Student st2("李四", 1, "LA");
//	st1 = st2;
//	return 0;
//}

//class Student;//前置声明
//class Same //基类
//{
//public:
//	friend void Fun(const Same& p, const Student& s);//友元声明
//protected:
//	string _name = "张三";
//};
//
//class Student : public Same //派生类
//{
//	friend void Fun(const Same& p, const Student& s);//友元声明
//protected:
//	int _stuid = 123;
//};
//
//void Fun(const Same& p, const Student& s)
//{
//	cout << p._name << endl;
//	cout << s._stuid << endl;
//}
//
//int main()
//{
//	Same sa;
//	Student st;
//	Fun(sa, st);
//	return 0;
//}

//class Same //基类
//{
//public:
//	string _name;
//	static int _count;//静态成员变量
//};
//int Same::_count = 0;//静态成员变量初始化
//
//class Student : public Same //派生类
//{
//protected:
//	int _stuNum;
//};

//class Person
//{
//public:
//	string _name; // 姓名
//	
//};
//// 使⽤虚继承Person类
//class Student : virtual public Person
//{
//protected:
//	int _num; //学号
//};
//// 使⽤虚继承Person类
//class Teacher : virtual public Person
//{
//protected:
//	int _id; // 职⼯编号
//};
//
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程
//};
//int main()
//{
//	// 使⽤虚继承，可以解决数据冗余和⼆义性
//	Assistant a;
//	a._name = "peter";
//	return 0;
//}
//
//int main()
//{
//	return 0;
//}

//int main()
//{
//	//Person p;
//	//Student s;
//	///*cout << &p._name << endl;
//	//cout << &s._name << endl;
//
//	//cout << &p._count << endl;
//	//cout << &s._count << endl;*/
//
//	//cout << Same::_count << endl;
//	//cout << Student::_count << endl;
//	//Same::_count++; //改变_count
//	//cout << p._count << endl;
//	//cout << s._count << endl;
//
//	return 0;
//}

//class Base1 { public: int _b1; };
//class Base2 { public: int _b2; };
//class Derive : public Base1, public Base2 { public: int _d; };
//int main()
//{
//    Derive d;
//    Base1* p1 = &d;
//    Base2* p2 = &d;
//    Derive* p3 = &d;
//    return 0;
//}

// Tire(轮胎)和Car(⻋)更符合has-a的关系

class Tire //轮胎
{
protected:
	string _brand; // 品牌
	size_t _size; // 尺⼨
};

class Car //车
{
protected:
	string _colour; // 颜⾊
	string _num; // ⻋牌号
	Tire _t1; // 轮胎
	Tire _t2; // 轮胎
};
class BMW : public Car 
{
public:
	void Drive() { cout << "BMW" << endl; }
};

// Car和BMW/Benz更符合is-a的关系
class Benz : public Car {
public:
	void Drive() { cout << "Benz" << endl; }
};

template<class T>
class vector
{
};
// stack和vector的关系，既符合is-a，也符合has-a
template<class T>
class stack : public vector<T>
{
};
template<class T>
class stack
{
public:
	vector<T> _v;
};

int main()
{
	return 0;
}
